'use strict'
import Vue from 'vue'

var key = 'innjia2016111703'
var SparkMD5 = function () {
  'use strict'
  var add32 = function (a, b) {
    return a + b & 4294967295
  }
  var hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']

  function cmn (q, a, b, x, s, t) {
    a = add32(add32(a, q), add32(x, t))
    return add32(a << s | a >>> 32 - s, b)
  }

  function ff (a, b, c, d, x, s, t) {
    return cmn(b & c | ~b & d, a, b, x, s, t)
  }

  function gg (a, b, c, d, x, s, t) {
    return cmn(b & d | c & ~d, a, b, x, s, t)
  }

  function hh (a, b, c, d, x, s, t) {
    return cmn(b ^ c ^ d, a, b, x, s, t)
  }

  function ii (a, b, c, d, x, s, t) {
    return cmn(c ^ (b | ~d), a, b, x, s, t)
  }

  function md5cycle (x, k) {
    var a = x[0]
    var b = x[1]
    var c = x[2]
    var d = x[3]
    a = ff(a, b, c, d, k[0], 7, -680876936)
    d = ff(d, a, b, c, k[1], 12, -389564586)
    c = ff(c, d, a, b, k[2], 17, 606105819)
    b = ff(b, c, d, a, k[3], 22, -1044525330)
    a = ff(a, b, c, d, k[4], 7, -176418897)
    d = ff(d, a, b, c, k[5], 12, 1200080426)
    c = ff(c, d, a, b, k[6], 17, -1473231341)
    b = ff(b, c, d, a, k[7], 22, -45705983)
    a = ff(a, b, c, d, k[8], 7, 1770035416)
    d = ff(d, a, b, c, k[9], 12, -1958414417)
    c = ff(c, d, a, b, k[10], 17, -42063)
    b = ff(b, c, d, a, k[11], 22, -1990404162)
    a = ff(a, b, c, d, k[12], 7, 1804603682)
    d = ff(d, a, b, c, k[13], 12, -40341101)
    c = ff(c, d, a, b, k[14], 17, -1502002290)
    b = ff(b, c, d, a, k[15], 22, 1236535329)
    a = gg(a, b, c, d, k[1], 5, -165796510)
    d = gg(d, a, b, c, k[6], 9, -1069501632)
    c = gg(c, d, a, b, k[11], 14, 643717713)
    b = gg(b, c, d, a, k[0], 20, -373897302)
    a = gg(a, b, c, d, k[5], 5, -701558691)
    d = gg(d, a, b, c, k[10], 9, 38016083)
    c = gg(c, d, a, b, k[15], 14, -660478335)
    b = gg(b, c, d, a, k[4], 20, -405537848)
    a = gg(a, b, c, d, k[9], 5, 568446438)
    d = gg(d, a, b, c, k[14], 9, -1019803690)
    c = gg(c, d, a, b, k[3], 14, -187363961)
    b = gg(b, c, d, a, k[8], 20, 1163531501)
    a = gg(a, b, c, d, k[13], 5, -1444681467)
    d = gg(d, a, b, c, k[2], 9, -51403784)
    c = gg(c, d, a, b, k[7], 14, 1735328473)
    b = gg(b, c, d, a, k[12], 20, -1926607734)
    a = hh(a, b, c, d, k[5], 4, -378558)
    d = hh(d, a, b, c, k[8], 11, -2022574463)
    c = hh(c, d, a, b, k[11], 16, 1839030562)
    b = hh(b, c, d, a, k[14], 23, -35309556)
    a = hh(a, b, c, d, k[1], 4, -1530992060)
    d = hh(d, a, b, c, k[4], 11, 1272893353)
    c = hh(c, d, a, b, k[7], 16, -155497632)
    b = hh(b, c, d, a, k[10], 23, -1094730640)
    a = hh(a, b, c, d, k[13], 4, 681279174)
    d = hh(d, a, b, c, k[0], 11, -358537222)
    c = hh(c, d, a, b, k[3], 16, -722521979)
    b = hh(b, c, d, a, k[6], 23, 76029189)
    a = hh(a, b, c, d, k[9], 4, -640364487)
    d = hh(d, a, b, c, k[12], 11, -421815835)
    c = hh(c, d, a, b, k[15], 16, 530742520)
    b = hh(b, c, d, a, k[2], 23, -995338651)
    a = ii(a, b, c, d, k[0], 6, -198630844)
    d = ii(d, a, b, c, k[7], 10, 1126891415)
    c = ii(c, d, a, b, k[14], 15, -1416354905)
    b = ii(b, c, d, a, k[5], 21, -57434055)
    a = ii(a, b, c, d, k[12], 6, 1700485571)
    d = ii(d, a, b, c, k[3], 10, -1894986606)
    c = ii(c, d, a, b, k[10], 15, -1051523)
    b = ii(b, c, d, a, k[1], 21, -2054922799)
    a = ii(a, b, c, d, k[8], 6, 1873313359)
    d = ii(d, a, b, c, k[15], 10, -30611744)
    c = ii(c, d, a, b, k[6], 15, -1560198380)
    b = ii(b, c, d, a, k[13], 21, 1309151649)
    a = ii(a, b, c, d, k[4], 6, -145523070)
    d = ii(d, a, b, c, k[11], 10, -1120210379)
    c = ii(c, d, a, b, k[2], 15, 718787259)
    b = ii(b, c, d, a, k[9], 21, -343485551)
    x[0] = add32(a, x[0])
    x[1] = add32(b, x[1])
    x[2] = add32(c, x[2])
    x[3] = add32(d, x[3])
  }

  function md5blk (s) {
    var md5blks = []
    var i
    for (i = 0; i < 64; i += 4) {
      md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24)
    }
    return md5blks
  }

  function md5blk_array (a) {
    var md5blks = []
    var i
    for (i = 0; i < 64; i += 4) {
      md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24)
    }
    return md5blks
  }

  function md51 (s) {
    var n = s.length
    var state = [1732584193, -271733879, -1732584194, 271733878]
    var i
    var length
    var tail
    var tmp
    var lo
    var hi
    for (i = 64; i <= n; i += 64) {
      md5cycle(state, md5blk(s.substring(i - 64, i)))
    }
    s = s.substring(i - 64)
    length = s.length
    tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    for (i = 0; i < length; i += 1) {
      tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3)
    }
    tail[i >> 2] |= 128 << (i % 4 << 3)
    if (i > 55) {
      md5cycle(state, tail)
      for (i = 0; i < 16; i += 1) {
        tail[i] = 0
      }
    }
    tmp = n * 8
    tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/)
    lo = parseInt(tmp[2], 16)
    hi = parseInt(tmp[1], 16) || 0
    tail[14] = lo
    tail[15] = hi
    md5cycle(state, tail)
    return state
  }

  function md51_array (a) {
    var n = a.length
    var state = [1732584193, -271733879, -1732584194, 271733878]
    var i
    var length
    var tail
    var tmp
    var lo
    var hi
    for (i = 64; i <= n; i += 64) {
      md5cycle(state, md5blk_array(a.subarray(i - 64, i)))
    }
    a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0)
    length = a.length
    tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    for (i = 0; i < length; i += 1) {
      tail[i >> 2] |= a[i] << (i % 4 << 3)
    }
    tail[i >> 2] |= 128 << (i % 4 << 3)
    if (i > 55) {
      md5cycle(state, tail)
      for (i = 0; i < 16; i += 1) {
        tail[i] = 0
      }
    }
    tmp = n * 8
    tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/)
    lo = parseInt(tmp[2], 16)
    hi = parseInt(tmp[1], 16) || 0
    tail[14] = lo
    tail[15] = hi
    md5cycle(state, tail)
    return state
  }

  function rhex (n) {
    var s = ''
    var j
    for (j = 0; j < 4; j += 1) {
      s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15]
    }
    return s
  }

  function hex (x) {
    var i
    for (i = 0; i < x.length; i += 1) {
      x[i] = rhex(x[i])
    }
    return x.join('')
  }

  if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') {
    add32 = function (x, y) {
      var lsw = (x & 65535) + (y & 65535)
      var msw = (x >> 16) + (y >> 16) + (lsw >> 16)
      return msw << 16 | lsw & 65535
    }
  }
  if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {
    (function () {
      function clamp (val, length) {
        val = val | 0 || 0
        if (val < 0) {
          return Math.max(val + length, 0)
        }
        return Math.min(val, length)
      }

      ArrayBuffer.prototype.slice = function (from, to) {
        var length = this.byteLength,
          begin = clamp(from, length),
          end = length,
          num,
          target,
          targetArray,
          sourceArray
        if (to !== undefined) {
          end = clamp(to, length)
        }
        if (begin > end) {
          return new ArrayBuffer(0)
        }
        num = end - begin
        target = new ArrayBuffer(num)
        targetArray = new Uint8Array(target)
        sourceArray = new Uint8Array(this, begin, num)
        targetArray.set(sourceArray)
        return target
      }
    })()
  }

  function toUtf8 (str) {
    if (/[\u0080-\uFFFF]/.test(str)) {
      str = unescape(encodeURIComponent(str))
    }
    return str
  }

  function utf8Str2ArrayBuffer (str, returnUInt8Array) {
    var length = str.length,
      buff = new ArrayBuffer(length),
      arr = new Uint8Array(buff),
      i
    for (i = 0; i < length; i += 1) {
      arr[i] = str.charCodeAt(i)
    }
    return returnUInt8Array ? arr : buff
  }

  function arrayBuffer2Utf8Str (buff) {
    return String.fromCharCode.apply(null, new Uint8Array(buff))
  }

  function concatenateArrayBuffers (first, second, returnUInt8Array) {
    var result = new Uint8Array(first.byteLength + second.byteLength)
    result.set(new Uint8Array(first))
    result.set(new Uint8Array(second), first.byteLength)
    return returnUInt8Array ? result : result.buffer
  }

  function hexToBinaryString (hex) {
    var bytes = [],
      length = hex.length,
      x
    for (x = 0; x < length - 1; x += 2) {
      bytes.push(parseInt(hex.substr(x, 2), 16))
    }
    return String.fromCharCode.apply(String, bytes)
  }

  function SparkMD5 () {
    this.reset()
  }

  SparkMD5.prototype.append = function (str) {
    this.appendBinary(toUtf8(str))
    return this
  }
  SparkMD5.prototype.appendBinary = function (contents) {
    this._buff += contents
    this._length += contents.length
    var length = this._buff.length,
      i
    for (i = 64; i <= length; i += 64) {
      md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)))
    }
    this._buff = this._buff.substring(i - 64)
    return this
  }
  SparkMD5.prototype.end = function (raw) {
    var buff = this._buff,
      length = buff.length,
      i, tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
      ret
    for (i = 0; i < length; i += 1) {
      tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3)
    }
    this._finish(tail, length)
    ret = hex(this._hash)
    if (raw) {
      ret = hexToBinaryString(ret)
    }
    this.reset()
    return ret
  }
  SparkMD5.prototype.reset = function () {
    this._buff = ''
    this._length = 0
    this._hash = [1732584193, -271733879, -1732584194, 271733878]
    return this
  }
  SparkMD5.prototype.getState = function () {
    return {
      buff: this._buff,
      length: this._length,
      hash: this._hash
    }
  }
  SparkMD5.prototype.setState = function (state) {
    this._buff = state.buff
    this._length = state.length
    this._hash = state.hash
    return this
  }
  SparkMD5.prototype.destroy = function () {
    delete this._hash
    delete this._buff
    delete this._length
  }
  SparkMD5.prototype._finish = function (tail, length) {
    var i = length,
      tmp, lo, hi
    tail[i >> 2] |= 128 << (i % 4 << 3)
    if (i > 55) {
      md5cycle(this._hash, tail)
      for (i = 0; i < 16; i += 1) {
        tail[i] = 0
      }
    }
    tmp = this._length * 8
    tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/)
    lo = parseInt(tmp[2], 16)
    hi = parseInt(tmp[1], 16) || 0
    tail[14] = lo
    tail[15] = hi
    md5cycle(this._hash, tail)
  }
  SparkMD5.hash = function (str, raw) {
    return SparkMD5.hashBinary(toUtf8(str), raw)
  }
  SparkMD5.hashBinary = function (content, raw) {
    var hash = md51(content),
      ret = hex(hash)
    return raw ? hexToBinaryString(ret) : ret
  }
  SparkMD5.ArrayBuffer = function () {
    this.reset()
  }
  SparkMD5.ArrayBuffer.prototype.append = function (arr) {
    var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),
      length = buff.length,
      i
    this._length += arr.byteLength
    for (i = 64; i <= length; i += 64) {
      md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)))
    }
    this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0)
    return this
  }
  SparkMD5.ArrayBuffer.prototype.end = function (raw) {
    var buff = this._buff,
      length = buff.length,
      tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
      i,
      ret
    for (i = 0; i < length; i += 1) {
      tail[i >> 2] |= buff[i] << (i % 4 << 3)
    }
    this._finish(tail, length)
    ret = hex(this._hash)
    if (raw) {
      ret = hexToBinaryString(ret)
    }
    this.reset()
    return ret
  }
  SparkMD5.ArrayBuffer.prototype.reset = function () {
    this._buff = new Uint8Array(0)
    this._length = 0
    this._hash = [1732584193, -271733879, -1732584194, 271733878]
    return this
  }
  SparkMD5.ArrayBuffer.prototype.getState = function () {
    var state = SparkMD5.prototype.getState.call(this)
    state.buff = arrayBuffer2Utf8Str(state.buff)
    return state
  }
  SparkMD5.ArrayBuffer.prototype.setState = function (state) {
    state.buff = utf8Str2ArrayBuffer(state.buff, true)
    return SparkMD5.prototype.setState.call(this, state)
  }
  SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy
  SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish
  SparkMD5.ArrayBuffer.hash = function (arr, raw) {
    var hash = md51_array(new Uint8Array(arr)),
      ret = hex(hash)
    return raw ? hexToBinaryString(ret) : ret
  }
  return SparkMD5
}
SparkMD5 = new SparkMD5()

function orderObj (obj) {
  let o = {}
  Object.keys(obj).forEach((key) => {
    o[key] = obj[key]
  })
  return o
}

function param (obj) {
  let arr = []
  for (let i in obj) {
    arr.push(i + '=' + obj[i])
  }
  return arr.join('&')
}

function getToken () {
  var user = localStorage.getItem('user')
  if (user) {
    user = JSON.parse(user)
    var oldToken = user.token.accessToken
    return oldToken
  } else {
    return ''
  }
}

var signature = function (methodId, params) {
  var result = {
    appid: 'H5',
    methodId: methodId + '',
    methodParam: JSON.stringify(params),
    nonce: Math.random().toString(),
    timestamp: new Date().getTime().toString()
  }
  // MD5字符串参数
  var str = decodeURIComponent(param(orderObj(result)))
  str += '&key=' + key
  var hash = SparkMD5.hash(str).toUpperCase()
  result.signature = hash
  return result
}

var rest = function (opt) {
  if (opt.log) {
    console.log('==== signData ==== rest.post ====')
    console.log(signature.run(opt.methodId, opt.data))
  }

  if (!opt.methodId) {
    throw new Error('methodId 不能为空！')
  }
  if (!opt.data) {
    opt.data = {}
  }

  $.ajax({
    url: Vue.prototype.GLOBAL.uipUrl,
    data: signature(opt.methodId, opt.data),
    type: 'post',
    // header: {Authorization:"Bearer "+loginToken},
    success: opt.success,
    error: opt.error,
    complete: opt.complete
  })
}

export default class mySign {
  rest (opt) {
    if (opt.log) {
      console.log('==== signData ==== rest.post ====')
      console.log(signature.run(opt.methodId, opt.data))
    }

    if (!opt.methodId) {
      throw new Error('methodId 不能为空！')
    }
    if (!opt.data) {
      opt.data = {}
    }
    var tokenFlag = ''

    if (opt.methodId == '4001' || opt.methodId == '4002' || opt.methodId == '4003' || opt.methodId == '5018') {

    } else {
      tokenFlag = getToken()
    }
    $.ajax({
      url: Vue.prototype.GLOBAL.uipUrl,
      data: signature('1057', {version: Vue.prototype.GLOBAL.currentVersion}),
      type: 'post',
      // header: {Authorization:"Bearer "+tokenFlag},
      success: function (data) {
        if (data.res.data.publishing) {
          window.location.href = '#/maintain'
        }
      }
    })

    return $.ajax({
      url: Vue.prototype.GLOBAL.uipUrl,
      data: signature(opt.methodId, opt.data),
      type: 'post',
      headers: {Authorization: 'Bearer ' + tokenFlag},
      success: function (res) {
        if (res.code == '402'){
          localStorage.removeItem('user')
          localStorage.removeItem('navi')
          window.location.href = '/'
        }else{
          opt.success(res);
        }
      },
      error: opt.error,
      complete: opt.complete
    })
  }
}
// $('#clickme').click(function(){
// var methodId = $("#methodId").val();
// var landlordId = $("#landlordId").val();
// console.log(methodId);
// console.log(landlordId);

// rest({
// methodId: methodId,
// data: {'landlordId': landlordId},
// success: function(res) {
// console.log(res);
// }
// });
// });
